Azure AI Face API (stable:v1.2)

2025/01/18 • 63 new methods

FaceDetectionOperations_DetectFromUrl (new)
Description > [!IMPORTANT] > Microsoft has retired or limited facial recognition capabilities that can be used to try to infer emotional states and identity attributes which, if misused, can subject people to stereotyping, discrimination or unfair denial of services. The retired capabilities are emotion and gender. The limited capabilities are age, smile, facial hair, hair and makeup. Email [Azure Face API](mailto:azureface@microsoft.com) if you have a responsible use case that would benefit from the use of any of the limited capabilities. Read more about this decision [here](https://azure.microsoft.com/blog/responsible-ai-investments-and-safeguards-for-facial-recognition/). * * No image will be stored. Only the extracted face feature(s) will be stored on server. The faceId is an identifier of the face feature and will be used in "Identify", "Verify", and "Find Similar". The stored face features will expire and be deleted at the time specified by faceIdTimeToLive after the original detection call. * Optional parameters include faceId, landmarks, and attributes. Attributes include headPose, glasses, occlusion, accessories, blur, exposure, noise, mask, and qualityForRecognition. Some of the results returned for specific attributes may not be highly accurate. * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB. * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size. * Up to 100 faces can be returned for an image. Faces are ranked by face rectangle size from large to small. * For optimal results when querying "Identify", "Verify", and "Find Similar" ('returnFaceId' is true), please use faces that are: frontal, clear, and with a minimum size of 200x200 pixels (100 pixels between eyes). * Different 'detectionModel' values can be provided. The availability of landmarks and supported attributes depends on the detection model specified. To use and compare different detection models, please refer to [here](https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/specify-detection-model). * Different 'recognitionModel' values are provided. If follow-up operations like "Verify", "Identify", "Find Similar" are needed, please specify the recognition model with 'recognitionModel' parameter. The default value for 'recognitionModel' is 'recognition_01', if latest model needed, please explicitly specify the model you need in this parameter. Once specified, the detected faceIds will be associated with the specified recognition model. More details, please refer to [here](https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/specify-recognition-model).
Reference Link ¶

⚼ Request

POST:  /detect
{
detectionModel: string ,
recognitionModel: string ,
returnFaceId: boolean ,
returnFaceAttributes: array ,
returnFaceLandmarks: boolean ,
returnRecognitionModel: boolean ,
faceIdTimeToLive: integer ,
body:
{
url: string ,
}
,
}

⚐ Response (200)

{
faceId: string ,
recognitionModel: enum ,
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
faceLandmarks:
{
pupilLeft:
{
x: number ,
y: number ,
}
,
pupilRight:
{
x: number ,
y: number ,
}
,
noseTip:
{
x: number ,
y: number ,
}
,
mouthLeft:
{
x: number ,
y: number ,
}
,
mouthRight:
{
x: number ,
y: number ,
}
,
eyebrowLeftOuter:
{
x: number ,
y: number ,
}
,
eyebrowLeftInner:
{
x: number ,
y: number ,
}
,
eyeLeftOuter:
{
x: number ,
y: number ,
}
,
eyeLeftTop:
{
x: number ,
y: number ,
}
,
eyeLeftBottom:
{
x: number ,
y: number ,
}
,
eyeLeftInner:
{
x: number ,
y: number ,
}
,
eyebrowRightInner:
{
x: number ,
y: number ,
}
,
eyebrowRightOuter:
{
x: number ,
y: number ,
}
,
eyeRightInner:
{
x: number ,
y: number ,
}
,
eyeRightTop:
{
x: number ,
y: number ,
}
,
eyeRightBottom:
{
x: number ,
y: number ,
}
,
eyeRightOuter:
{
x: number ,
y: number ,
}
,
noseRootLeft:
{
x: number ,
y: number ,
}
,
noseRootRight:
{
x: number ,
y: number ,
}
,
noseLeftAlarTop:
{
x: number ,
y: number ,
}
,
noseRightAlarTop:
{
x: number ,
y: number ,
}
,
noseLeftAlarOutTip:
{
x: number ,
y: number ,
}
,
noseRightAlarOutTip:
{
x: number ,
y: number ,
}
,
upperLipTop:
{
x: number ,
y: number ,
}
,
upperLipBottom:
{
x: number ,
y: number ,
}
,
underLipTop:
{
x: number ,
y: number ,
}
,
underLipBottom:
{
x: number ,
y: number ,
}
,
}
,
faceAttributes:
{
age: number ,
smile: number ,
facialHair:
{
moustache: number ,
beard: number ,
sideburns: number ,
}
,
glasses: enum ,
headPose:
{
pitch: number ,
roll: number ,
yaw: number ,
}
,
hair:
{
bald: number ,
invisible: boolean ,
hairColor:
[
{
color: enum ,
confidence: number ,
}
,
]
,
}
,
occlusion:
{
foreheadOccluded: boolean ,
eyeOccluded: boolean ,
mouthOccluded: boolean ,
}
,
accessories:
[
{
type: enum ,
confidence: number ,
}
,
]
,
blur:
{
blurLevel: enum ,
value: number ,
}
,
exposure:
{
exposureLevel: enum ,
value: number ,
}
,
noise:
{
noiseLevel: enum ,
value: number ,
}
,
mask:
{
noseAndMouthCovered: boolean ,
type: enum ,
}
,
qualityForRecognition: enum ,
}
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_CreateLivenessSession (new)
Description A session is best for client device scenarios where developers want to authorize a client device to perform only a liveness detection without granting full access to their resource. Created sessions have a limited life span and only authorize clients to perform the desired action before access is expired. Permissions includes... > * * Ability to call /detectLiveness/singleModal for up to 3 retries. * A token lifetime of 10 minutes. > [!NOTE] > Client access can be revoked by deleting the session using the Delete Liveness Session operation. To retrieve a result, use the Get Liveness Session. To audit the individual requests that a client has made to your resource, use the List Liveness Session Audit Entries.
Reference Link ¶

⚼ Request

POST:  /detectLiveness-sessions
{
body:
{
livenessOperationMode: enum ,
deviceCorrelationIdSetInClient: boolean ,
enableSessionImage: boolean ,
livenessModelVersion: enum ,
deviceCorrelationId: string ,
authTokenTimeToLiveInSeconds: integer ,
}
,
}

⚐ Response (200)

{
sessionId: string ,
authToken: string ,
status: enum ,
modelVersion: enum ,
results:
{
attempts:
[
{
attemptId: integer ,
attemptStatus: enum ,
result:
{
livenessDecision: enum ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
digest: string ,
sessionImageId: string ,
}
,
error:
{
code: string ,
message: string ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
}
,
}
,
]
,
}
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_GetLivenessSessionResult (new)
Description Get session result of detectLiveness/singleModal call.
Reference Link ¶

⚼ Request

GET:  /detectLiveness-sessions/{sessionId}
{
sessionId: string ,
}

⚐ Response (200)

{
sessionId: string ,
authToken: string ,
status: enum ,
modelVersion: enum ,
results:
{
attempts:
[
{
attemptId: integer ,
attemptStatus: enum ,
result:
{
livenessDecision: enum ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
digest: string ,
sessionImageId: string ,
}
,
error:
{
code: string ,
message: string ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
}
,
}
,
]
,
}
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_DeleteLivenessSession (new)
Description > [!NOTE] > Deleting a session deactivates the Session Auth Token by blocking future API calls made with that Auth Token. While this can be used to remove any access for that token, those requests will still count towards overall resource rate limits. It's best to leverage TokenTTL to limit length of tokens in the case that it is misused.
Reference Link ¶

⚼ Request

DELETE:  /detectLiveness-sessions/{sessionId}
{
sessionId: string ,
}

⚐ Response (204)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_CreateLivenessWithVerifySession (new)
Description A session is best for client device scenarios where developers want to authorize a client device to perform only a liveness detection without granting full access to their resource. Created sessions have a limited life span and only authorize clients to perform the desired action before access is expired. Permissions includes... > * * Ability to call /detectLivenessWithVerify/singleModal for up to 3 retries. * A token lifetime of 10 minutes. > [!NOTE] > > * > * Client access can be revoked by deleting the session using the Delete Liveness With Verify Session operation. > * To retrieve a result, use the Get Liveness With Verify Session. > * To audit the individual requests that a client has made to your resource, use the List Liveness With Verify Session Audit Entries.
Reference Link ¶

⚼ Request

POST:  /detectLivenessWithVerify-sessions
{
livenessOperationMode: string ,
deviceCorrelationIdSetInClient: boolean ,
enableSessionImage: boolean ,
livenessModelVersion: string ,
deviceCorrelationId: string ,
authTokenTimeToLiveInSeconds: integer ,
returnVerifyImageHash: boolean ,
verifyConfidenceThreshold: number ,
verifyImage: file ,
}

⚐ Response (200)

{
sessionId: string ,
authToken: string ,
status: enum ,
modelVersion: enum ,
results:
{
verifyReferences:
[
{
referenceType: enum ,
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
qualityForRecognition: enum ,
}
,
]
,
attempts:
[
{
attemptId: integer ,
attemptStatus: enum ,
result:
{
livenessDecision: enum ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
digest: string ,
sessionImageId: string ,
verifyResult:
{
matchConfidence: number ,
isIdentical: boolean ,
}
,
verifyImageHash: string ,
}
,
error:
{
code: string ,
message: string ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
}
,
}
,
]
,
}
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_GetLivenessWithVerifySessionResult (new)
Description Get session result of detectLivenessWithVerify/singleModal call.
Reference Link ¶

⚼ Request

GET:  /detectLivenessWithVerify-sessions/{sessionId}
{
sessionId: string ,
}

⚐ Response (200)

{
sessionId: string ,
authToken: string ,
status: enum ,
modelVersion: enum ,
results:
{
verifyReferences:
[
{
referenceType: enum ,
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
qualityForRecognition: enum ,
}
,
]
,
attempts:
[
{
attemptId: integer ,
attemptStatus: enum ,
result:
{
livenessDecision: enum ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
digest: string ,
sessionImageId: string ,
verifyResult:
{
matchConfidence: number ,
isIdentical: boolean ,
}
,
verifyImageHash: string ,
}
,
error:
{
code: string ,
message: string ,
targets:
{
color:
{
faceRectangle:
{
top: integer ,
left: integer ,
width: integer ,
height: integer ,
}
,
}
,
}
,
}
,
}
,
]
,
}
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_DeleteLivenessWithVerifySession (new)
Description > [!NOTE] > Deleting a session deactivates the Session Auth Token by blocking future API calls made with that Auth Token. While this can be used to remove any access for that token, those requests will still count towards overall resource rate limits. It's best to leverage TokenTTL to limit length of tokens in the case that it is misused.
Reference Link ¶

⚼ Request

DELETE:  /detectLivenessWithVerify-sessions/{sessionId}
{
sessionId: string ,
}

⚐ Response (204)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetFaceLists (new)
Description List Face Lists' faceListId, name, userData and recognitionModel. To get face information inside Face List use "Get Face List".
Reference Link ¶

⚼ Request

GET:  /facelists
{
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
faceListId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetFaceList (new)
Description Retrieve a Face List's faceListId, name, userData, recognitionModel and faces in the Face List.
Reference Link ¶

⚼ Request

GET:  /facelists/{faceListId}
{
faceListId: string ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
faceListId: string ,
persistedFaces:
[
{
persistedFaceId: string ,
userData: string ,
}
,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_CreateFaceList (new)
Description Up to 64 Face Lists are allowed in one subscription. Face List is a list of faces, up to 1,000 faces, and used by "Find Similar From Face List". After creation, user should use "Add Face List Face" to import the faces. No image will be stored. Only the extracted face feature(s) will be stored on server until "Delete Face List" is called. "Find Similar" is used for scenario like finding celebrity-like faces, similar face filtering, or as a light way face identification. But if the actual use is to identify person, please use Person Group / Large Person Group and "Identify". Please consider Large Face List when the face number is large. It can support up to 1,000,000 faces.
Reference Link ¶

⚼ Request

PUT:  /facelists/{faceListId}
{
faceListId: string ,
body:
{
name: string ,
userData: string ,
recognitionModel: enum ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_UpdateFaceList (new)
Description Update information of a Face List, including name and userData.
Reference Link ¶

⚼ Request

PATCH:  /facelists/{faceListId}
{
faceListId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_DeleteFaceList (new)
Description Delete a specified Face List.
Reference Link ¶

⚼ Request

DELETE:  /facelists/{faceListId}
{
faceListId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_AddFaceListFaceFromUrl (new)
Description To deal with an image containing multiple faces, input face can be specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face. No image will be stored. Only the extracted face feature(s) will be stored on server until "Delete Face List Face" or "Delete Face List" is called. Note that persistedFaceId is different from faceId generated by "Detect". > * * Higher face image quality means better recognition precision. Please consider high-quality faces: frontal, clear, and face size is 200x200 pixels (100 pixels between eyes) or bigger. * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB. * "targetFace" rectangle should contain one face. Zero or multiple faces will be regarded as an error. If the provided "targetFace" rectangle is not returned from "Detect", there's no guarantee to detect and add the face successfully. * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose, or large occlusions will cause failures. * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size. * Different 'detectionModel' values can be provided. To use and compare different detection models, please refer to [here](https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/specify-detection-model).
Reference Link ¶

⚼ Request

POST:  /facelists/{faceListId}/persistedfaces
{
faceListId: string ,
targetFace: array ,
detectionModel: string ,
userData: string ,
body:
{
url: string ,
}
,
}

⚐ Response (200)

{
persistedFaceId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_DeleteFaceListFace (new)
Description Adding/deleting faces to/from a same Face List are processed sequentially and to/from different Face Lists are in parallel.
Reference Link ¶

⚼ Request

DELETE:  /facelists/{faceListId}/persistedfaces/{persistedFaceId}
{
faceListId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceRecognitionOperations_FindSimilar (new)
Description Depending on the input the returned similar faces list contains faceIds or persistedFaceIds ranked by similarity. Find similar has two working modes, "matchPerson" and "matchFace". "matchPerson" is the default mode that it tries to find faces of the same person as possible by using internal same-person thresholds. It is useful to find a known person's other photos. Note that an empty list will be returned if no faces pass the internal thresholds. "matchFace" mode ignores same-person thresholds and returns ranked similar faces anyway, even the similarity is low. It can be used in the cases like searching celebrity-looking faces. The 'recognitionModel' associated with the query faceId should be the same as the 'recognitionModel' used by the target faceId array.
Reference Link ¶

⚼ Request

POST:  /findsimilars
{
body:
{
faceId: string ,
maxNumOfCandidatesReturned: integer ,
mode: enum ,
faceIds:
[
string ,
]
,
}
,
}

⚐ Response (200)

{
confidence: number ,
faceId: string ,
persistedFaceId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceRecognitionOperations_Group (new)
Description > * * The output is one or more disjointed face groups and a messyGroup. A face group contains faces that have similar looking, often of the same person. Face groups are ranked by group size, i.e. number of faces. Notice that faces belonging to a same person might be split into several groups in the result. * MessyGroup is a special face group containing faces that cannot find any similar counterpart face from original faces. The messyGroup will not appear in the result if all faces found their counterparts. * Group API needs at least 2 candidate faces and 1000 at most. We suggest to try "Verify Face To Face" when you only have 2 candidate faces. * The 'recognitionModel' associated with the query faces' faceIds should be the same.
Reference Link ¶

⚼ Request

POST:  /group
{
body:
{
faceIds:
[
string ,
]
,
}
,
}

⚐ Response (200)

{
groups:
[
string ,
]
,
messyGroup:
[
string ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceRecognitionOperations_IdentifyFromPersonGroup (new)
Description For each face in the faceIds array, Face Identify will compute similarities between the query face and all the faces in the Person Group (given by personGroupId), and return candidate person(s) for that face ranked by similarity confidence. The Person Group should be trained to make it ready for identification. See more in "Train Person Group". > [!NOTE] > > * > * The algorithm allows more than one face to be identified independently at the same request, but no more than 10 faces. > * Each person could have more than one face, but no more than 248 faces. > * Higher face image quality means better identification precision. Please consider high-quality faces: frontal, clear, and face size is 200x200 pixels (100 pixels between eyes) or bigger. > * Number of candidates returned is restricted by maxNumOfCandidatesReturned and confidenceThreshold. If no person is identified, the returned candidates will be an empty array. > * Try "Find Similar" when you need to find similar faces from a Face List/Large Face List instead of a Person Group. > * The 'recognitionModel' associated with the query faces' faceIds should be the same as the 'recognitionModel' used by the target Person Group.
Reference Link ¶

⚼ Request

POST:  /identify
{
body:
{
faceIds:
[
string ,
]
,
personGroupId: string ,
maxNumOfCandidatesReturned: integer ,
confidenceThreshold: number ,
}
,
}

⚐ Response (200)

{
faceId: string ,
candidates:
[
{
personId: string ,
confidence: number ,
}
,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetLargeFaceLists (new)
Description To get face information inside largeFaceList use "Get Large Face List Face". Large Face Lists are stored in alphabetical order of largeFaceListId. > * * "start" parameter (string, optional) specifies an ID value from which returned entries will have larger IDs based on string comparison. Setting "start" to an empty value indicates that entries should be returned starting from the first item. * "top" parameter (int, optional) determines the maximum number of entries to be returned, with a limit of up to 1000 entries per call. To retrieve additional entries beyond this limit, specify "start" with the personId of the last entry returned in the current call. > [!TIP] > > * For example, there are total 5 items with their IDs: "itemId1", ..., "itemId5". > * "start=&top=" will return all 5 items. > * "start=&top=2" will return "itemId1", "itemId2". > * "start=itemId2&top=3" will return "itemId3", "itemId4", "itemId5".
Reference Link ¶

⚼ Request

GET:  /largefacelists
{
start: string ,
top: integer ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
largeFaceListId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetLargeFaceList (new)
Description Retrieve a Large Face List's largeFaceListId, name, userData and recognitionModel.
Reference Link ¶

⚼ Request

GET:  /largefacelists/{largeFaceListId}
{
largeFaceListId: string ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
largeFaceListId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_CreateLargeFaceList (new)
Description Large Face List is a list of faces, up to 1,000,000 faces, and used by "Find Similar From Large Face List". After creation, user should use Add Large Face List Face to import the faces and Train Large Face List to make it ready for "Find Similar". No image will be stored. Only the extracted face feature(s) will be stored on server until Delete Large Face List is called. "Find Similar" is used for scenario like finding celebrity-like faces, similar face filtering, or as a light way face identification. But if the actual use is to identify person, please use Person Group / Large Person Group and "Identify". > [!NOTE] > > * > * Free-tier subscription quota: 64 Large Face Lists. > * S0-tier subscription quota: 1,000,000 Large Face Lists.
Reference Link ¶

⚼ Request

PUT:  /largefacelists/{largeFaceListId}
{
largeFaceListId: string ,
body:
{
name: string ,
userData: string ,
recognitionModel: enum ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_UpdateLargeFaceList (new)
Description Update information of a Large Face List, including name and userData.
Reference Link ¶

⚼ Request

PATCH:  /largefacelists/{largeFaceListId}
{
largeFaceListId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_DeleteLargeFaceList (new)
Description Adding/deleting faces to/from a same Large Face List are processed sequentially and to/from different Large Face Lists are in parallel.
Reference Link ¶

⚼ Request

DELETE:  /largefacelists/{largeFaceListId}
{
largeFaceListId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetLargeFaceListFaces (new)
Description Faces are stored in alphabetical order of persistedFaceId created in "Add Large Face List Face". > * * "start" parameter (string, optional) specifies an ID value from which returned entries will have larger IDs based on string comparison. Setting "start" to an empty value indicates that entries should be returned starting from the first item. * "top" parameter (int, optional) determines the maximum number of entries to be returned, with a limit of up to 1000 entries per call. To retrieve additional entries beyond this limit, specify "start" with the personId of the last entry returned in the current call. > [!TIP] > > * For example, there are total 5 items with their IDs: "itemId1", ..., "itemId5". > * "start=&top=" will return all 5 items. > * "start=&top=2" will return "itemId1", "itemId2". > * "start=itemId2&top=3" will return "itemId3", "itemId4", "itemId5".
Reference Link ¶

⚼ Request

GET:  /largefacelists/{largeFaceListId}/persistedfaces
{
largeFaceListId: string ,
start: string ,
top: integer ,
}

⚐ Response (200)

{
persistedFaceId: string ,
userData: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_AddLargeFaceListFaceFromUrl (new)
Description To deal with an image containing multiple faces, input face can be specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face. No image will be stored. Only the extracted face feature(s) will be stored on server until "Delete Large Face List Face" or "Delete Large Face List" is called. Note that persistedFaceId is different from faceId generated by "Detect". > * * Higher face image quality means better recognition precision. Please consider high-quality faces: frontal, clear, and face size is 200x200 pixels (100 pixels between eyes) or bigger. * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB. * "targetFace" rectangle should contain one face. Zero or multiple faces will be regarded as an error. If the provided "targetFace" rectangle is not returned from "Detect", there's no guarantee to detect and add the face successfully. * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose, or large occlusions will cause failures. * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size. * Different 'detectionModel' values can be provided. To use and compare different detection models, please refer to [here](https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/specify-detection-model). > [!NOTE] > > * > * Free-tier subscription quota: 1,000 faces per Large Face List. > * S0-tier subscription quota: 1,000,000 faces per Large Face List.
Reference Link ¶

⚼ Request

POST:  /largefacelists/{largeFaceListId}/persistedfaces
{
largeFaceListId: string ,
targetFace: array ,
detectionModel: string ,
userData: string ,
body:
{
url: string ,
}
,
}

⚐ Response (200)

{
persistedFaceId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetLargeFaceListFace (new)
Description Retrieve persisted face in Large Face List by largeFaceListId and persistedFaceId.
Reference Link ¶

⚼ Request

GET:  /largefacelists/{largeFaceListId}/persistedfaces/{persistedFaceId}
{
largeFaceListId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{
persistedFaceId: string ,
userData: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_UpdateLargeFaceListFace (new)
Description Update a specified face's userData field in a Large Face List by its persistedFaceId.
Reference Link ¶

⚼ Request

PATCH:  /largefacelists/{largeFaceListId}/persistedfaces/{persistedFaceId}
{
largeFaceListId: string ,
persistedFaceId: string ,
body:
{
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_DeleteLargeFaceListFace (new)
Description Delete a face from a Large Face List by specified largeFaceListId and persistedFaceId.
Reference Link ¶

⚼ Request

DELETE:  /largefacelists/{largeFaceListId}/persistedfaces/{persistedFaceId}
{
largeFaceListId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_TrainLargeFaceList (new)
Description Training is a crucial step that only a trained Large Face List can be used by "Find Similar From Large Face List". The training task is an asynchronous task. Training time depends on the number of face entries in a Large Face List. It could be in seconds, or up to half an hour for 1,000,000 faces. To check training completion, please use "Get Large Face List Training Status".
Reference Link ¶

⚼ Request

POST:  /largefacelists/{largeFaceListId}/train
{
largeFaceListId: string ,
}

⚐ Response (202)

{
operation-location: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceListOperations_GetLargeFaceListTrainingStatus (new)
Description To check the Large Face List training status completed or still ongoing. Large Face List training is an asynchronous operation triggered by "Train Large Face List". Training time depends on the number of face entries in a Large Face List. It could be in seconds, or up to half an hour for 1,000,000 faces.
Reference Link ¶

⚼ Request

GET:  /largefacelists/{largeFaceListId}/training
{
largeFaceListId: string ,
}

⚐ Response (200)

{
status: enum ,
createdDateTime: string ,
lastActionDateTime: string ,
lastSuccessfulTrainingDateTime: string ,
message: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetLargePersonGroups (new)
Description Large Person Groups are stored in alphabetical order of largePersonGroupId. > * * "start" parameter (string, optional) specifies an ID value from which returned entries will have larger IDs based on string comparison. Setting "start" to an empty value indicates that entries should be returned starting from the first item. * "top" parameter (int, optional) determines the maximum number of entries to be returned, with a limit of up to 1000 entries per call. To retrieve additional entries beyond this limit, specify "start" with the personId of the last entry returned in the current call. > [!TIP] > > * For example, there are total 5 items with their IDs: "itemId1", ..., "itemId5". > * "start=&top=" will return all 5 items. > * "start=&top=2" will return "itemId1", "itemId2". > * "start=itemId2&top=3" will return "itemId3", "itemId4", "itemId5".
Reference Link ¶

⚼ Request

GET:  /largepersongroups
{
start: string ,
top: integer ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
largePersonGroupId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetLargePersonGroup (new)
Description Retrieve the information of a Large Person Group, including its name, userData and recognitionModel. This API returns Large Person Group information only, use "Get Large Person Group Persons" instead to retrieve person information under the Large Person Group.
Reference Link ¶

⚼ Request

GET:  /largepersongroups/{largePersonGroupId}
{
largePersonGroupId: string ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
largePersonGroupId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_CreateLargePersonGroup (new)
Description A Large Person Group is a container holding the uploaded person data, including the face recognition features. It can hold up to 1,000,000 entities. After creation, use "Create Large Person Group Person" to add person into the group, and call "Train Large Person Group" to get this group ready for "Identify From Large Person Group". No image will be stored. Only the person's extracted face feature(s) and userData will be stored on server until "Delete Large Person Group Person" or "Delete Large Person Group" is called. 'recognitionModel' should be specified to associate with this Large Person Group. The default value for 'recognitionModel' is 'recognition_01', if the latest model needed, please explicitly specify the model you need in this parameter. New faces that are added to an existing Large Person Group will use the recognition model that's already associated with the collection. Existing face feature(s) in a Large Person Group can't be updated to features extracted by another version of recognition model. > [!NOTE] > > * > * Free-tier subscription quota: 1,000 Large Person Groups. > * S0-tier subscription quota: 1,000,000 Large Person Groups.
Reference Link ¶

⚼ Request

PUT:  /largepersongroups/{largePersonGroupId}
{
largePersonGroupId: string ,
body:
{
name: string ,
userData: string ,
recognitionModel: enum ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_UpdateLargePersonGroup (new)
Description Update an existing Large Person Group's name and userData. The properties keep unchanged if they are not in request body.
Reference Link ¶

⚼ Request

PATCH:  /largepersongroups/{largePersonGroupId}
{
largePersonGroupId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_DeleteLargePersonGroup (new)
Description Delete an existing Large Person Group with specified personGroupId. Persisted data in this Large Person Group will be deleted.
Reference Link ¶

⚼ Request

DELETE:  /largepersongroups/{largePersonGroupId}
{
largePersonGroupId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetLargePersonGroupPersons (new)
Description Persons are stored in alphabetical order of personId created in "Create Large Person Group Person". > * * "start" parameter (string, optional) specifies an ID value from which returned entries will have larger IDs based on string comparison. Setting "start" to an empty value indicates that entries should be returned starting from the first item. * "top" parameter (int, optional) determines the maximum number of entries to be returned, with a limit of up to 1000 entries per call. To retrieve additional entries beyond this limit, specify "start" with the personId of the last entry returned in the current call. > [!TIP] > > * For example, there are total 5 items with their IDs: "itemId1", ..., "itemId5". > * "start=&top=" will return all 5 items. > * "start=&top=2" will return "itemId1", "itemId2". > * "start=itemId2&top=3" will return "itemId3", "itemId4", "itemId5".
Reference Link ¶

⚼ Request

GET:  /largepersongroups/{largePersonGroupId}/persons
{
largePersonGroupId: string ,
start: string ,
top: integer ,
}

⚐ Response (200)

{
personId: string ,
name: string ,
userData: string ,
persistedFaceIds:
[
string ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_CreateLargePersonGroupPerson (new)
Description > [!NOTE] > > * > * Free-tier subscription quota: > * 1,000 persons in all Large Person Groups. > * S0-tier subscription quota: > * 1,000,000 persons per Large Person Group. > * 1,000,000 Large Person Groups. > * 1,000,000,000 persons in all Large Person Groups.
Reference Link ¶

⚼ Request

POST:  /largepersongroups/{largePersonGroupId}/persons
{
largePersonGroupId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{
personId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetLargePersonGroupPerson (new)
Description Retrieve a person's name and userData, and the persisted faceIds representing the registered person face feature(s).
Reference Link ¶

⚼ Request

GET:  /largepersongroups/{largePersonGroupId}/persons/{personId}
{
largePersonGroupId: string ,
personId: string ,
}

⚐ Response (200)

{
personId: string ,
name: string ,
userData: string ,
persistedFaceIds:
[
string ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_UpdateLargePersonGroupPerson (new)
Description Update name or userData of a person.
Reference Link ¶

⚼ Request

PATCH:  /largepersongroups/{largePersonGroupId}/persons/{personId}
{
largePersonGroupId: string ,
personId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_DeleteLargePersonGroupPerson (new)
Description Delete an existing person from a Large Person Group. The persistedFaceId, userData, person name and face feature(s) in the person entry will all be deleted.
Reference Link ¶

⚼ Request

DELETE:  /largepersongroups/{largePersonGroupId}/persons/{personId}
{
largePersonGroupId: string ,
personId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_AddLargePersonGroupPersonFaceFromUrl (new)
Description To deal with an image containing multiple faces, input face can be specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face. No image will be stored. Only the extracted face feature(s) will be stored on server until "Delete Large Person Group Person Face", "Delete Large Person Group Person" or "Delete Large Person Group" is called. Note that persistedFaceId is different from faceId generated by "Detect". > * * Each person entry can hold up to 248 faces. * Higher face image quality means better recognition precision. Please consider high-quality faces: frontal, clear, and face size is 200x200 pixels (100 pixels between eyes) or bigger. * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB. * "targetFace" rectangle should contain one face. Zero or multiple faces will be regarded as an error. If the provided "targetFace" rectangle is not returned from "Detect", there's no guarantee to detect and add the face successfully. * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose, or large occlusions will cause failures. * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size. * Different 'detectionModel' values can be provided. To use and compare different detection models, please refer to [here](https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/specify-detection-model).
Reference Link ¶

⚼ Request

POST:  /largepersongroups/{largePersonGroupId}/persons/{personId}/persistedfaces
{
largePersonGroupId: string ,
personId: string ,
targetFace: array ,
detectionModel: string ,
userData: string ,
body:
{
url: string ,
}
,
}

⚐ Response (200)

{
persistedFaceId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetLargePersonGroupPersonFace (new)
Description Retrieve person face information. The persisted person face is specified by its largePersonGroupId, personId and persistedFaceId.
Reference Link ¶

⚼ Request

GET:  /largepersongroups/{largePersonGroupId}/persons/{personId}/persistedfaces/{persistedFaceId}
{
largePersonGroupId: string ,
personId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{
persistedFaceId: string ,
userData: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_UpdateLargePersonGroupPersonFace (new)
Description Update a person persisted face's userData field.
Reference Link ¶

⚼ Request

PATCH:  /largepersongroups/{largePersonGroupId}/persons/{personId}/persistedfaces/{persistedFaceId}
{
largePersonGroupId: string ,
personId: string ,
persistedFaceId: string ,
body:
{
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_DeleteLargePersonGroupPersonFace (new)
Description Adding/deleting faces to/from a same person will be processed sequentially. Adding/deleting faces to/from different persons are processed in parallel.
Reference Link ¶

⚼ Request

DELETE:  /largepersongroups/{largePersonGroupId}/persons/{personId}/persistedfaces/{persistedFaceId}
{
largePersonGroupId: string ,
personId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_TrainLargePersonGroup (new)
Description The training task is an asynchronous task. Training time depends on the number of person entries, and their faces in a Large Person Group. It could be in several seconds, or up to half a hour for 1,000,000 persons. To check training status, please use "Get Large Person Group Training Status".
Reference Link ¶

⚼ Request

POST:  /largepersongroups/{largePersonGroupId}/train
{
largePersonGroupId: string ,
}

⚐ Response (202)

{
operation-location: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetLargePersonGroupTrainingStatus (new)
Description Training time depends on the number of person entries, and their faces in a Large Person Group. It could be in seconds, or up to half an hour for 1,000,000 persons.
Reference Link ¶

⚼ Request

GET:  /largepersongroups/{largePersonGroupId}/training
{
largePersonGroupId: string ,
}

⚐ Response (200)

{
status: enum ,
createdDateTime: string ,
lastActionDateTime: string ,
lastSuccessfulTrainingDateTime: string ,
message: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetPersonGroups (new)
Description Person Groups are stored in alphabetical order of personGroupId. > * * "start" parameter (string, optional) specifies an ID value from which returned entries will have larger IDs based on string comparison. Setting "start" to an empty value indicates that entries should be returned starting from the first item. * "top" parameter (int, optional) determines the maximum number of entries to be returned, with a limit of up to 1000 entries per call. To retrieve additional entries beyond this limit, specify "start" with the personId of the last entry returned in the current call. > [!TIP] > > * For example, there are total 5 items with their IDs: "itemId1", ..., "itemId5". > * "start=&top=" will return all 5 items. > * "start=&top=2" will return "itemId1", "itemId2". > * "start=itemId2&top=3" will return "itemId3", "itemId4", "itemId5".
Reference Link ¶

⚼ Request

GET:  /persongroups
{
start: string ,
top: integer ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
personGroupId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetPersonGroup (new)
Description Retrieve Person Group name, userData and recognitionModel. To get person information under this personGroup, use "Get Person Group Persons".
Reference Link ¶

⚼ Request

GET:  /persongroups/{personGroupId}
{
personGroupId: string ,
returnRecognitionModel: boolean ,
}

⚐ Response (200)

{
name: string ,
userData: string ,
recognitionModel: enum ,
personGroupId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_CreatePersonGroup (new)
Description A Person Group is a container holding the uploaded person data, including face recognition features. After creation, use "Create Person Group Person" to add persons into the group, and then call "Train Person Group" to get this group ready for "Identify From Person Group". No image will be stored. Only the person's extracted face feature(s) and userData will be stored on server until "Delete Person Group Person" or "Delete Person Group" is called. 'recognitionModel' should be specified to associate with this Person Group. The default value for 'recognitionModel' is 'recognition_01', if the latest model needed, please explicitly specify the model you need in this parameter. New faces that are added to an existing Person Group will use the recognition model that's already associated with the collection. Existing face feature(s) in a Person Group can't be updated to features extracted by another version of recognition model. > [!NOTE] > > * > * Free-tier subscription quota: 1,000 Person Groups. Each holds up to 1,000 persons. > * S0-tier subscription quota: 1,000,000 Person Groups. Each holds up to 10,000 persons. > * to handle larger scale face identification problem, please consider using Large Person Group.
Reference Link ¶

⚼ Request

PUT:  /persongroups/{personGroupId}
{
personGroupId: string ,
body:
{
name: string ,
userData: string ,
recognitionModel: enum ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_UpdatePersonGroup (new)
Description Update an existing Person Group's name and userData. The properties keep unchanged if they are not in request body.
Reference Link ¶

⚼ Request

PATCH:  /persongroups/{personGroupId}
{
personGroupId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_DeletePersonGroup (new)
Description Delete an existing Person Group with specified personGroupId. Persisted data in this Person Group will be deleted.
Reference Link ¶

⚼ Request

DELETE:  /persongroups/{personGroupId}
{
personGroupId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetPersonGroupPersons (new)
Description Persons are stored in alphabetical order of personId created in "Create Person Group Person". > * * "start" parameter (string, optional) specifies an ID value from which returned entries will have larger IDs based on string comparison. Setting "start" to an empty value indicates that entries should be returned starting from the first item. * "top" parameter (int, optional) determines the maximum number of entries to be returned, with a limit of up to 1000 entries per call. To retrieve additional entries beyond this limit, specify "start" with the personId of the last entry returned in the current call. > [!TIP] > > * For example, there are total 5 items with their IDs: "itemId1", ..., "itemId5". > * "start=&top=" will return all 5 items. > * "start=&top=2" will return "itemId1", "itemId2". > * "start=itemId2&top=3" will return "itemId3", "itemId4", "itemId5".
Reference Link ¶

⚼ Request

GET:  /persongroups/{personGroupId}/persons
{
personGroupId: string ,
start: string ,
top: integer ,
}

⚐ Response (200)

{
personId: string ,
name: string ,
userData: string ,
persistedFaceIds:
[
string ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_CreatePersonGroupPerson (new)
Description > [!NOTE] > > * > * Free-tier subscription quota: > * 1,000 persons in all Person Groups. > * S0-tier subscription quota: > * 10,000 persons per Person Group. > * 1,000,000 Person Groups. > * 100,000,000 persons in all Person Groups.
Reference Link ¶

⚼ Request

POST:  /persongroups/{personGroupId}/persons
{
personGroupId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{
personId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetPersonGroupPerson (new)
Description Retrieve a person's name and userData, and the persisted faceIds representing the registered person face feature(s).
Reference Link ¶

⚼ Request

GET:  /persongroups/{personGroupId}/persons/{personId}
{
personGroupId: string ,
personId: string ,
}

⚐ Response (200)

{
personId: string ,
name: string ,
userData: string ,
persistedFaceIds:
[
string ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_UpdatePersonGroupPerson (new)
Description Update name or userData of a person.
Reference Link ¶

⚼ Request

PATCH:  /persongroups/{personGroupId}/persons/{personId}
{
personGroupId: string ,
personId: string ,
body:
{
name: string ,
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_DeletePersonGroupPerson (new)
Description Delete an existing person from a Person Group. The persistedFaceId, userData, person name and face feature(s) in the person entry will all be deleted.
Reference Link ¶

⚼ Request

DELETE:  /persongroups/{personGroupId}/persons/{personId}
{
personGroupId: string ,
personId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_AddPersonGroupPersonFaceFromUrl (new)
Description To deal with an image containing multiple faces, input face can be specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face. No image will be stored. Only the extracted face feature(s) will be stored on server until "Delete Person Group Person Face", "Delete Person Group Person" or "Delete Person Group" is called. Note that persistedFaceId is different from faceId generated by "Detect". > * * Each person entry can hold up to 248 faces. * Higher face image quality means better recognition precision. Please consider high-quality faces: frontal, clear, and face size is 200x200 pixels (100 pixels between eyes) or bigger. * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB. * "targetFace" rectangle should contain one face. Zero or multiple faces will be regarded as an error. If the provided "targetFace" rectangle is not returned from "Detect", there's no guarantee to detect and add the face successfully. * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose, or large occlusions will cause failures. * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size. * Different 'detectionModel' values can be provided. To use and compare different detection models, please refer to [here](https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/specify-detection-model).
Reference Link ¶

⚼ Request

POST:  /persongroups/{personGroupId}/persons/{personId}/persistedfaces
{
personGroupId: string ,
personId: string ,
targetFace: array ,
detectionModel: string ,
userData: string ,
body:
{
url: string ,
}
,
}

⚐ Response (200)

{
persistedFaceId: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetPersonGroupPersonFace (new)
Description Retrieve person face information. The persisted person face is specified by its personGroupId, personId and persistedFaceId.
Reference Link ¶

⚼ Request

GET:  /persongroups/{personGroupId}/persons/{personId}/persistedfaces/{persistedFaceId}
{
personGroupId: string ,
personId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{
persistedFaceId: string ,
userData: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_UpdatePersonGroupPersonFace (new)
Description Update a person persisted face's userData field.
Reference Link ¶

⚼ Request

PATCH:  /persongroups/{personGroupId}/persons/{personId}/persistedfaces/{persistedFaceId}
{
personGroupId: string ,
personId: string ,
persistedFaceId: string ,
body:
{
userData: string ,
}
,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_DeletePersonGroupPersonFace (new)
Description Adding/deleting faces to/from a same person will be processed sequentially. Adding/deleting faces to/from different persons are processed in parallel.
Reference Link ¶

⚼ Request

DELETE:  /persongroups/{personGroupId}/persons/{personId}/persistedfaces/{persistedFaceId}
{
personGroupId: string ,
personId: string ,
persistedFaceId: string ,
}

⚐ Response (200)

{}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_TrainPersonGroup (new)
Description The training task is an asynchronous task. Training time depends on the number of person entries, and their faces in a Person Group. It could be several seconds to minutes. To check training status, please use "Get Person Group Training Status".
Reference Link ¶

⚼ Request

POST:  /persongroups/{personGroupId}/train
{
personGroupId: string ,
}

⚐ Response (202)

{
operation-location: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
PersonGroupOperations_GetPersonGroupTrainingStatus (new)
Description To check Person Group training status completed or still ongoing. Person Group training is an asynchronous operation triggered by "Train Person Group" API.
Reference Link ¶

⚼ Request

GET:  /persongroups/{personGroupId}/training
{
personGroupId: string ,
}

⚐ Response (200)

{
status: enum ,
createdDateTime: string ,
lastActionDateTime: string ,
lastSuccessfulTrainingDateTime: string ,
message: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
LivenessSessionOperations_GetSessionImage (new)
Description Get session image stored during the liveness session.
Reference Link ¶

⚼ Request

GET:  /sessionImages/{sessionImageId}
{
sessionImageId: string ,
}

⚐ Response (200)

{
$schema: file ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}
FaceRecognitionOperations_VerifyFaceToFace (new)
Description > [!NOTE] > > * > * Higher face image quality means better identification precision. Please consider high-quality faces: frontal, clear, and face size is 200x200 pixels (100 pixels between eyes) or bigger. > * For the scenarios that are sensitive to accuracy please make your own judgment. > * The 'recognitionModel' associated with the both faces should be the same.
Reference Link ¶

⚼ Request

POST:  /verify
{
body:
{
faceId1: string ,
faceId2: string ,
}
,
}

⚐ Response (200)

{
isIdentical: boolean ,
confidence: number ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
}
,
}
,
}